home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / fsmconv.c < prev    next >
C/C++ Source or Header  |  1996-07-10  |  18KB  |  538 lines
  1. /*
  2.     it's a FINITE_STATE_MACHINE which handles the state of the
  3.                     conversation.
  4.  
  5.                       FSM_CONV
  6.  Function: handels the state of the conversation resource.
  7.            There may be the following states:
  8.         - RESET;
  9.         - SEND;
  10.         - Rcv=receive;
  11.         - RCVD_CONFIRM=received confirm;
  12.         - RCVD_CONFIRM_SEND=received confirm send;
  13.         - RCVD_CONFIRM_DEALL=received confirm deallocate;
  14.         - PREP_TO_RCV_DEFER=prepare to receive defer;
  15.         - DEALL_DEFER=deallocate defer;
  16.         - PEND_DEALL=pending deallocate.
  17.  
  18.  Note that the PEND_DEALL is an intermedia state, in that case LU does not
  19.  returns control to the transaction program.
  20.  
  21.   CopyRight 1995. Nicholas Poljakov all rights reserved.
  22. */
  23.  
  24. #include <stdio.h>
  25. #include <malloc.h>
  26. #include <state1.h>
  27. #include <rcb.h>
  28. #include <lucb.h>
  29. #include <string.h>
  30.  
  31. #define Remote 114
  32. #define Slocal 115
  33. int sk_r_wt(void *);
  34. int SendBlock(void *, void *);
  35. int setrc(void *, void *);
  36. int sendhsf(void *);
  37. int sendhs(void *);
  38. int sendbm(void *, void *);
  39. int sendat(void *);
  40. int rtsend(void *);
  41. unsigned long rmfmh5(void *, void *);
  42. int recwait(void *);
  43. int rcvru(void *, void *);
  44. int rcvhs(void *, void *, void *, void *);
  45. int ralloc(void *, void *);
  46. int psrm(int, void *, void *);
  47. int ps_conv(int, void *);
  48. int proterr(void *, unsigned long);
  49. int preptrcv(void *, void *);
  50. int post_rcb(void *);
  51. struct repass *postopen(void *);
  52. int phsrec(void *);
  53. int pfmh5(void *);
  54. int opndst(void *);
  55. int obtsess(void *, unsigned char);
  56. int Lrf_handler(void *);
  57. int get_sess(void *, void *);
  58. int get_attr(void *);
  59. int fsm_error(unsigned char, void *);
  60. int flush (void *);
  61. int dcp(void *);
  62. int dealloc(void *);
  63. int crtp(void *);
  64. int conv(void *);
  65. int chkparm(void *, void *);
  66. int check_end(unsigned int, void *);
  67. struct rqb *call_appl(void *);
  68. int buffmng(unsigned char, void *, void *, void *, unsigned, unsigned char, unsigned);
  69. unsigned long attltck(void *);
  70. unsigned long attacheck(void *);
  71. char *cgetmem(int, int);
  72. int sendhsf(void *);
  73. int opndst(void *);
  74. int alloc_rcb(void *, void *);
  75. int allocate(void *);
  76. int clsdst(void *);
  77.  
  78. int fsm_conv(p1,p2,p_rcb)
  79.  unsigned char p1;
  80.  unsigned char p2;
  81.  struct rcb *p_rcb;
  82. {
  83.  struct tcb *p_tcb;
  84.  unsigned char type;
  85.  char *p;
  86.  
  87. #if OS_TYPE == 1
  88. /*********  Trace facility **********/
  89. unsigned int rtype;   /* type of record */
  90. unsigned int pnum;    /* point number */
  91. char pname[8];        /* name of module */
  92. char *drec;           /* record for dump */
  93. int  lenr;            /* record length */
  94.  
  95. rtype = INPROC;
  96. strcpy(pname, "fsmconv");
  97. pnum = 1;
  98. lenr = sizeof(struct rcb) + 2;
  99. drec = malloc(lenr);
  100. drec[0] = p1;
  101. drec[1] = p2;
  102. p = drec + 2;
  103. memcpy(p, p_rcb, lenr - 2);
  104. gtf(rtype, pname, pnum, drec, lenr);
  105. free(drec);
  106. /***********************************/
  107. #endif
  108.  
  109.   if((p1 == 'r')||(p1 == 'R'))
  110.   p1=Remote;
  111.   if((p1 == 's')||(p1 == 'S'))
  112.   p1=Slocal;
  113.  
  114.  switch(p1)
  115.    {
  116.    case Remote:
  117.       switch (p2)
  118.         {
  119.     case ATTACH:
  120.           {
  121.               if(p_rcb->conv_state==RESET)
  122.               {
  123.                   p_rcb->conv_state = Rcv;
  124.                   goto ex0;
  125.               }
  126.               else
  127.                   {
  128.                      goto ex_1;
  129.                   }
  130.           }
  131.     case send_indicator:
  132.          {
  133.              if(p_rcb->conv_state==Rcv) {
  134.                  p_rcb->conv_state = SEND;
  135.                  goto ex0;
  136.              }
  137.                else
  138.                        {
  139.                           goto ex_1;
  140.                        }
  141.          }
  142.     case confirm_indicator:
  143.          {
  144.              if(p_rcb->conv_state==Rcv) {
  145.                  p_rcb->conv_state = rcvd_confirm;
  146.                  goto ex0;
  147.              }
  148.                else
  149.                        {
  150.                            goto ex_1;
  151.                        }
  152.           }
  153.     case confirm_send_ind:
  154.           {
  155.               if(p_rcb->conv_state==Rcv) {
  156.                 p_rcb->conv_state = rcvd_confirm_send;
  157.                 goto ex0;
  158.               }
  159.                 else
  160.                         {
  161.                             goto ex_1;
  162.                         }
  163.           }
  164.     case confirm_dealloc_ind:
  165.          {
  166.               if(p_rcb->conv_state==Rcv) {
  167.                 p_rcb->conv_state = rcvd_confirm_deall;
  168.                 goto ex0;
  169.               }
  170.                 else
  171.                         {
  172.                             goto ex_1;
  173.                         }
  174.          }
  175.     case program_error_rc:
  176.     case service_error_rc:
  177.        {
  178.             switch (p_rcb->conv_state)
  179.                    {  case RESET:
  180.                       case rcvd_confirm:
  181.                       case rcvd_confirm_send:
  182.                       case rcvd_confirm_deall:
  183.                       case END_CONV:
  184.                                            goto ex_1;
  185.                       case SEND:
  186.                       case PREP_TO_RCV_DEFER:
  187.                       case Deallocate_defer:
  188.                       case pend_deall:
  189.                                        {
  190.                                            p_rcb->conv_state = Rcv;
  191.                                              fsm_error(RESET, p_rcb);
  192.                                              goto ex0;
  193.                                        }
  194.                       case Rcv:
  195.                                        {
  196.                                            fsm_error(RESET, p_rcb);
  197.                                            goto ex0;
  198.                                        }
  199.                    }
  200.        }
  201.     case Dealloc_normal_rc:
  202.        {
  203.            if((p_rcb->conv_state == SEND)||(p_rcb->conv_state==Rcv)) {
  204.                p_rcb->conv_state = END_CONV;
  205.                goto ex0;
  206.            }
  207.              else { goto ex_1; }
  208.        }
  209.     case Dealloc_abend_rc:
  210.     case RESOURCE_FAILURE_RC:
  211.     case ALLOCATION_ERROR_RC:
  212.        {
  213.         if((p_rcb->conv_state == SEND)||(p_rcb->conv_state==Rcv)||
  214.             (p_rcb->conv_state == PREP_TO_RCV_DEFER)||
  215.             (p_rcb->conv_state == Deallocate_defer)||
  216.             (p_rcb->conv_state==pend_deall)) {
  217.                p_rcb->conv_state = END_CONV;
  218.                fsm_error(RESET, p_rcb);
  219.                goto ex0;
  220.         }
  221.           else { goto ex_1; }
  222.        }
  223.     case Deallocated_ind:
  224.        {
  225.         if(p_rcb->conv_state == Deallocate_defer) {
  226.             p_rcb->conv_state = RESET;
  227.             goto ex0;
  228.         }
  229.           else { goto ex_1; }
  230.        }
  231.    }
  232.     case Slocal:
  233.      switch (p2)
  234.       {
  235.         case Allocate:
  236.         {
  237.             if(p_rcb->conv_state == RESET) {
  238.                 p_rcb->conv_state = SEND;
  239.                 goto ex0;
  240.             }
  241.           else { goto ex_1; }
  242.         }
  243.         case Send_data:
  244.         {
  245.             if((p_rcb->conv_state == RESET)||(p_rcb->conv_state==SEND)||
  246.                (p_rcb->conv_state == pend_deall)) {
  247.                if(p_rcb->conv_state == SEND) {
  248.                   goto ex0;
  249.                }
  250.                goto ex_1;
  251.             }
  252.                 else
  253.                    {
  254.                      p_tcb = p_rcb -> p_tcb;
  255.                      goto ex1;
  256.                    }
  257.         }
  258.         case PREP_TO_RCV_FLUSH:
  259.         case PREP_TO_RCV_CONFIRM_SH:
  260.         case PREP_TO_RCV_CONFIRM_LG:
  261.         {
  262.             if((p_rcb->conv_state == RESET)||(p_rcb->conv_state==SEND)||
  263.               (p_rcb->conv_state == pend_deall)) {
  264.                 if(p_rcb->conv_state == SEND) {
  265.                     p_rcb->conv_state=Rcv;
  266.                     goto ex0;
  267.                 }
  268.                 goto ex_1;
  269.             }
  270.                else
  271.                {
  272.                  p_tcb = p_rcb -> p_tcb;
  273.                  goto ex1;
  274.                }
  275.         }
  276.         case PREP_TO_RCV_DEFER:
  277.         {
  278.             if((p_rcb->conv_state == RESET)||(p_rcb->conv_state==SEND)||
  279.                (p_rcb->conv_state == pend_deall)) {
  280.                if(p_rcb->conv_state == SEND) {
  281.                   p_rcb->conv_state=PREP_TO_RCV_DEFER;
  282.                   goto ex0;
  283.                }
  284.                goto ex_1;
  285.             }
  286.                else
  287.                {
  288.                  p_tcb = p_rcb -> p_tcb;
  289.                  goto ex1;
  290.                }
  291.         }
  292.         case Flush:
  293.         case Confirm:
  294.                      switch (p_rcb->conv_state)
  295.                       {
  296.                         case RESET:
  297.                         case pend_deall:
  298.                             {
  299.                                 goto ex_1;
  300.                             }
  301.                         case SEND:
  302.                             {
  303.                                 goto ex0;
  304.                             }
  305.                         case Rcv:
  306.                         case rcvd_confirm:
  307.                         case rcvd_confirm_send:
  308.                         case rcvd_confirm_deall:
  309.                         case END_CONV:
  310.                             {
  311.                                p_tcb = p_rcb -> p_tcb;
  312.                                goto ex1;
  313.                             }
  314.                         case PREP_TO_RCV_DEFER:
  315.                             {
  316.                                 p_rcb->conv_state = Rcv;
  317.                                 goto ex0;
  318.                             }
  319.                         case deall_defer:
  320.                             {
  321.                                  p_rcb->conv_state = pend_deall;
  322.                                  goto ex0;
  323.                             }
  324.                       }
  325.         case Send_error:
  326.                       switch (p_rcb->conv_state)
  327.                             {
  328.                                case RESET:
  329.                                case pend_deall:
  330.                                    {
  331.                                        goto ex_1;
  332.                                    }
  333.                                case SEND:
  334.                                    {
  335.                                        goto ex0;
  336.                                    }
  337.                                case Rcv:
  338.                                case rcvd_confirm:
  339.                                case rcvd_confirm_send:
  340.                                case rcvd_confirm_deall:
  341.                                    {
  342.                                        p_rcb->conv_state = SEND;
  343.                                        goto ex0;
  344.                                    }
  345.                                case PREP_TO_RCV_DEFER:
  346.                                case Deallocate_defer:
  347.                                case END_CONV:
  348.                                    {
  349.                                       p_tcb = p_rcb -> p_tcb;
  350.                                       goto ex1;
  351.                                    }
  352.                             }
  353.         case Receive_and_wait:
  354.       switch (p_rcb->conv_state)
  355.        {
  356.          case RESET:
  357.          case pend_deall:
  358.             {
  359.                goto ex_1;
  360.             }
  361.          case SEND:
  362.             {
  363.                  p_rcb->conv_state = Rcv;
  364.                  if(p_rcb -> send_ll_remainder == 0) {
  365.              p = (char *)&((*p_rcb).first_out);
  366.                      type = PREP_TO_RCV_FLUSH;
  367.                      buffmng('A', NULL, p, p_rcb, 0, 0, type);
  368.                      sendhsf(p_rcb);
  369.                      goto ex0;
  370.                  }
  371.                   else
  372.                        {
  373.                           p_tcb = p_rcb -> p_tcb;
  374.                           dcp(p_tcb);
  375.                           goto ex0;
  376.                        }
  377.             }
  378.          case Rcv:
  379.             {
  380.               goto ex0;
  381.             }
  382.          case rcvd_confirm:
  383.          case rcvd_confirm_send:
  384.          case rcvd_confirm_deall:
  385.          case PREP_TO_RCV_DEFER:
  386.          case Deallocate_defer:
  387.          case END_CONV:
  388.             {
  389.               p_tcb = p_rcb -> p_tcb;
  390.               goto ex1;
  391.             }
  392.          }
  393.         case Post_on_receipt:
  394.         case Wait:
  395.         case Test:
  396.         case Receive_immediate:
  397.         case Request_to_send:
  398.   {
  399.      if((p_rcb->conv_state == RESET)||(p_rcb->conv_state==Rcv)||
  400.         (p_rcb->conv_state == pend_deall)) {
  401.         if(p_rcb->conv_state == Rcv) {
  402.             goto ex0;
  403.          }
  404.          goto ex_1;
  405.      }
  406.         else
  407.              {
  408.                if(p2==Request_to_send) {
  409.                 if(p_rcb->conv_state == rcvd_confirm) {
  410.                     goto ex0;
  411.                 }
  412.                }
  413.                   else
  414.                         {
  415.                            p_tcb = p_rcb -> p_tcb;
  416.                            goto ex1;
  417.                          }
  418.              }
  419.   }
  420.     case COnfirmed:
  421.                     switch (p_rcb->conv_state)
  422.                     {
  423.                        case RESET:
  424.                        case pend_deall:
  425.                            {
  426.                                goto ex_1;
  427.                            }
  428.                        case SEND:
  429.                        case Rcv:
  430.                        case PREP_TO_RCV_DEFER:
  431.                        case Deallocate_defer:
  432.                        case END_CONV:
  433.                            {
  434.                               p_tcb = p_rcb -> p_tcb;
  435.                               goto ex1;
  436.                            }
  437.                        case rcvd_confirm:
  438.                           {
  439.                             p_rcb->conv_state = Rcv;
  440.                             goto ex0;
  441.                           }
  442.                        case rcvd_confirm_send:
  443.                           {
  444.                               p_rcb->conv_state = SEND;
  445.                               goto ex0;
  446.                           }
  447.                        case rcvd_confirm_deall:
  448.                           {
  449.                            p_rcb->conv_state = END_CONV;
  450.                            goto ex0;
  451.                           }
  452.                     }
  453.         case Deallocate_flush:
  454.         case Deallocate_confirm:
  455.         case Deallocate_defer:
  456.                     {
  457.                         if((p_rcb->conv_state == RESET)||
  458.                            (p_rcb->conv_state==SEND)||
  459.                            (p_rcb->conv_state == pend_deall)) {
  460.                            if(p_rcb->conv_state == SEND) {
  461.                                if (p2==Deallocate_flush) {
  462.                                  p_rcb->conv_state = RESET;
  463.                                }
  464.                                if (p2==Deallocate_confirm)
  465.                                  p_rcb->conv_state = pend_deall;
  466.                                if (p2==Deallocate_defer)
  467.                                  p_rcb->conv_state = Deallocate_defer;
  468.                                 goto ex0;
  469.                            }
  470.                              else
  471.                                     {
  472.                                         goto ex_1;
  473.                                     }
  474.                         }
  475.                            else
  476.                                   {
  477.                                        p_tcb = p_rcb -> p_tcb;
  478.                                        goto ex1; }
  479.                                   }
  480.         case Deallocate_abend:
  481.                        {
  482.                         if((p_rcb->conv_state == RESET)||
  483.                            (p_rcb->conv_state==END_CONV)||
  484.                            (p_rcb->conv_state == pend_deall)) {
  485.                            if(p_rcb->conv_state == END_CONV) {
  486.                                p_tcb = p_rcb -> p_tcb;
  487.                                goto ex1;
  488.                            }
  489.                              else
  490.                                     {
  491.                                         goto ex_1;
  492.                                      }
  493.                         }
  494.                             else
  495.                             {
  496.                                 p_rcb->conv_state = RESET;
  497.                                 goto ex0;
  498.                             }
  499.                        }
  500.         case Deallocate_local:
  501.                        {
  502.                         if((p_rcb->conv_state == RESET)||
  503.                            (p_rcb->conv_state==END_CONV)||
  504.                            (p_rcb->conv_state == pend_deall)) {
  505.                            if(p_rcb->conv_state == END_CONV) {
  506.                             p_rcb->conv_state = RESET;
  507.                             goto ex0;
  508.                            }
  509.                               else {
  510.                                       goto ex_1;
  511.                                    }
  512.                            }
  513.                            else
  514.                                    {
  515.                                      p_tcb = p_rcb -> p_tcb;
  516.                                      goto ex1;
  517.                                    }
  518.                        }
  519.         case Get_attributes:
  520.                        {
  521.                         if((p_rcb->conv_state == RESET)||
  522.                            (p_rcb->conv_state == pend_deall)) {
  523.                             goto ex_1;
  524.                         }
  525.                            else
  526.                                 {
  527.                                     goto ex0;
  528.                                 }
  529.                        }
  530.       }
  531.    }
  532.  ex0: return(0);
  533.  ex1:
  534.       dcp(p_tcb);
  535.       return(1);
  536.  ex_1: return(-1);
  537. }
  538.